package com.sdkx.wear_os.utils;

import java.nio.ByteBuffer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 通用字符串管理类
 */
public class StringUtils {

    /**
     * 字符串转Ascii字节数组
     *
     * @param str 字符串
     */
    public static byte[] strToAscii(String str) {
        char[] chars = str.toCharArray();
        byte[] b = new byte[chars.length];
        for (int i = 0; i < chars.length; i++) {
            b[i] = (byte) chars[i];
        }
        return b;
    }

    /**
     * 16进制字符串转Ascii字符串
     *
     * @param hexStr 16进制字符串
     */
    public static String hexStrToAscii(String hexStr) {
        StringBuilder output = new StringBuilder("");
        for (int i = 0; i < hexStr.length(); i += 2) {
            String str = hexStr.substring(i, i + 2);
            output.append((char) Integer.parseInt(str, 16));
        }
        return output.toString();
    }

    /**
     * Ascii字符串转字符串
     *
     * @param asciiStr ascii字符串
     */
    public static String asciiToStr(String asciiStr) {
        StringBuilder sbu = new StringBuilder();
        String[] chars = asciiStr.split(",");
        System.out.println(chars[0]);
        for (String aChar : chars) {
            sbu.append((char) Integer.parseInt(aChar));
        }
        return sbu.toString();
    }

    /**
     * 字符串转换为16进制字符串
     *
     * @param str 字符串
     */
    public static String strToHexStr(String str) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            int ch = str.charAt(i);
            String s4 = Integer.toHexString(ch);
            sb.append(s4);
        }
        return sb.toString();
    }

    /**
     * 字节数组转16进制字符串
     *
     * @param bytes 字节数组
     */
    public static String bytesToHexStr(byte[] bytes) {
        StringBuilder sb = new StringBuilder(bytes.length);
        String sTemp;
        for (byte b : bytes) {
            sTemp = Integer.toHexString(0xFF & b);
            if (sTemp.length() < 2)
                sb.append(0);
            sb.append(sTemp.toUpperCase());
        }
        return sb.toString();
    }

    /**
     * 16进制字符串转10进制
     *
     * @param hexStr 16进制字符串
     */
    public static int hexStrToInt(String hexStr) {
        hexStr = hexStr.toUpperCase();
        int max = hexStr.length();
        int result = 0;
        for (int i = max; i > 0; i--) {
            char c = hexStr.charAt(i - 1);
            int algorism = 0;
            if (c >= '0' && c <= '9') {
                algorism = c - '0';
            } else {
                algorism = c - 55;
            }
            result += Math.pow(16, max - i) * algorism;
        }
        return result;
    }

    /**
     * 16进制转字符串
     *
     * @param hexStr     16进制字符串
     * @param encodeType 编码类型4：Unicode，2：普通编码
     */
    public static String hexStrToStr(String hexStr, int encodeType) {
        StringBuilder result = new StringBuilder();
        int max = hexStr.length() / encodeType;
        for (int i = 0; i < max; i++) {
            char c = (char) hexStrToInt(hexStr.substring(i
                    * encodeType, (i + 1) * encodeType));
            result.append(c);
        }
        return result.toString();
    }

    /**
     * 16进制字符串转字节数组
     *
     * @param hexStr 16进制字符串
     */
    public static byte[] hexStrToBytes(String hexStr) {
        int l = hexStr.length() / 2;
        byte[] ret = new byte[l];
        for (int i = 0; i < l; i++) {
            ret[i] = (byte) Integer.valueOf(hexStr.substring(i * 2, i * 2 + 2), 16).byteValue();
        }
        return ret;
    }

    /**
     * double转16进制 8字节
     *
     * @param b double值
     */
    public static String doubleToHexStr(double b) {
        if (b == 0.0) {
            return "0000000000000000";
        }
        try {
            // 将双精度浮点型值转换为长整型的位模式
            long longValue = Double.doubleToLongBits(b);
            // 将长整型值转换为十六进制字符串表示
            return Long.toHexString(longValue);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "0000000000000000";
    }

    /**
     * float转byte数组 4字节
     *
     * @param f float值
     */
    public static byte[] floatToBytes(float f) {
        return ByteBuffer.allocate(4).putFloat(f).array();
    }

    /**
     * 为16进制数据补位 前补0
     *
     * @param hexStr 需要补位的数据
     * @param hexLen 需要补充到的长度（不允许小于需要补位数据的长度）
     */
    public static String hexPaddingZero(String hexStr, Integer hexLen) {
        int len = hexLen - hexStr.length();
        //判断需要生成长度是否小于0，小于0不符合规则
        if (len < 0) {
            return hexStr.substring(0, hexLen);
        }
        if (len < hexLen) {
            for (int i = 0; i < len; i++) {
                hexStr = "0" + hexStr;
            }
        }
        return hexStr;
    }

    /**
     * 为16进制数据补位 后补0
     *
     * @param hexStr 需要补位的数据
     * @param hexLen 需要补充到的长度（不允许小于需要补位数据的长度）
     */
    public static String hexPaddingZeroLift(String hexStr, Integer hexLen) {
        int len = hexLen - hexStr.length();
        //判断需要生成长度是否小于0，小于0不符合规则
        if (len < 0) {
            return hexStr.substring(0, hexLen);
        }
        if (len < hexLen) {
            for (int i = 0; i < len; i++) {
                hexStr = hexStr + "0";
            }
        }
        return hexStr;
    }

    /**
     * long转字节数据 高位在前，低位在后 4字节
     *
     * @param l long数据
     */
    public static byte[] unLongToH4bytes(long l) {
        byte[] b = new byte[4];
        b[0] = (byte) (l >> 24 & 0xff);
        b[1] = (byte) (l >> 16 & 0xff);
        b[2] = (byte) (l >> 8 & 0xff);
        b[3] = (byte) (l & 0xff);
        return b;
    }

    /**
     * long转字节数据 高位在前，低位在后 2字节
     *
     * @param l long数据
     */
    public static byte[] unLongToH2bytes(long l) {
        byte[] b = new byte[2];
        b[0] = (byte) (l >> 8 & 0xff);
        b[1] = (byte) (l & 0xff);
        return b;
    }

    /**
     * 雷登服务提取时间方法的
     *
     * @param dateHex 时间的16进制
     */
    public static String hexStrToDate(String dateHex) {
        //定义循环控制变量
        int year = Integer.parseInt(dateHex.substring(0, 2), 16);
        int month = Integer.parseInt(dateHex.substring(2, 4), 16);
        int day = Integer.parseInt(dateHex.substring(4, 6), 16);
        int hour = Integer.parseInt(dateHex.substring(6, 8), 16);
        int minutes = Integer.parseInt(dateHex.substring(8, 10), 16);
        int seconds = Integer.parseInt(dateHex.substring(10, 12), 16);
        return year + "年" + month + "月" + day + "日  " + hour + "时" + minutes + "分" + seconds + "秒";
    }

    /**
     * 计算CRC16/Modbus校验码 低位在前,高位在后
     *
     * @param hexStr 十六进制字符串
     */
    public static String getCrc(String hexStr) {
        //如果字符串为奇数，就在前面加上0，防止后面报错
        if (hexStr.length() % 2 != 0) {
            hexStr = "0" + hexStr;
        }
        byte[] bytes = hexStrToBytes(hexStr);
        int CRC = 0x0000ffff;
        int polynomial = 0x0000a001;
        int i, j;
        for (i = 0; i < bytes.length; i++) {
            CRC ^= ((int) bytes[i] & 0x000000ff);
            for (j = 0; j < 8; j++) {
                if ((CRC & 0x00000001) != 0) {
                    CRC >>= 1;
                    CRC ^= polynomial;
                } else {
                    CRC >>= 1;
                }
            }
        }
        CRC = ((CRC & 0x0000FF00) >> 8) | ((CRC & 0x000000FF) << 8);
        //换成用String形式转换，如果用Integer形式，第一位为0的话会忽略掉
        String crc = String.format("%04X", CRC);
        crc = crc.toUpperCase();
        return crc;
    }


    /**
     * 校验位异或计算
     *
     * @param bytes 字节数组
     */
    public static byte compute(byte[] bytes) {
        byte checksum = 0;
        for (byte b : bytes) {
            checksum ^= b;
        }
        return checksum;
    }

    /**
     * 正则处理 只保留"[^a-zA-Z\\d,.*$-]"
     *
     * @param content 数据
     */
    public static String strRegular(String content) {
        // 定义正则表达式，匹配所有非英文数字标点
        Pattern pattern = Pattern.compile("[^a-zA-Z\\d,.*$-]");
        // 创建Matcher对象进行匹配操作
        Matcher matcher = pattern.matcher(content);
        // 使用replaceAll函数将匹配到的内容全部替换为空格
        return matcher.replaceAll("");
    }

}
